home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / RSPFHDR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-29  |  5.0 KB  |  178 lines
  1. /* Mods by PA0GRI */
  2.  
  3. #include "global.h"
  4. #include "mbuf.h"
  5. #include "internet.h"
  6. #include "ip.h"
  7. #include "rspf.h"
  8.  
  9. #if !defined(_lint)
  10. static char rcsid[] OPTIONAL = "$Id: rspfhdr.c,v 1.8 1996/08/29 12:11:16 root Exp root $";
  11. #endif
  12.  
  13. #ifdef RSPF
  14.  
  15. /* Convert RRH header in internal format to an mbuf in external format */
  16. struct mbuf *
  17. htonrrh (struct rrh *rrh, struct mbuf *data, struct pseudo_header *ph)
  18. {
  19. struct mbuf *bp;
  20. register unsigned char *cp, *ck;
  21. int16 checksum;
  22.  
  23.     /* Allocate RRH header and fill it in */
  24.     bp = pushdown (data, RRHLEN);    /* pushdown never fails */
  25.  
  26.     cp = bp->data;
  27.     *cp++ = uchar (rrh->version);    /* Version number */
  28.     *cp++ = RSPF_RRH;    /* Type number */
  29.     ck = cp;
  30.     cp = put16 (cp, 0);    /* Clear checksum */
  31.     cp = put32 (cp, rrh->addr);    /* Source address */
  32.     cp = put16 (cp, rrh->seq);    /* Last packet sent sequence number */
  33.     *cp = uchar (rrh->flags);    /* Flags */
  34.  
  35.     /* All zeros and all ones is equivalent in one's complement arithmetic;
  36.      * the spec requires us to change zeros into ones to distinguish an
  37.       * all-zero checksum from no checksum at all
  38.      */
  39.     if ((checksum = cksum (ph, bp, ph->length)) == 0)
  40.         /* was checksum = 0xffffffff - odd, since this is an int16! */
  41.         checksum = 0xffff;
  42.     (void) put16 (ck, checksum);
  43.     return bp;
  44. }
  45.  
  46.  
  47.  
  48. /* Convert RSPF packet header in internal format to an mbuf in external
  49.  * format, without calculating the checksum.
  50.  */
  51. struct mbuf *
  52. htonrspf (struct rspfpacketh *pkth, struct mbuf *data)
  53. {
  54. struct mbuf *bp;
  55. register unsigned char *cp;
  56.  
  57.     /* Allocate packet header and fill it in */
  58.     bp = pushdown (data, RSPFPKTLEN);    /* pushdown never fails */
  59.  
  60.     cp = bp->data;
  61.     *cp++ = uchar (pkth->version);    /* Version number */
  62.     *cp++ = uchar (pkth->type);    /* Type number */
  63.     *cp++ = pkth->fragn;    /* The fragment number */
  64.     *cp++ = pkth->fragtot;    /* The total number of fragments */
  65.     cp = (unsigned char *) put16 (cp, pkth->csum);    /* The checksum */
  66.     *cp++ = pkth->sync;    /* The sync octet */
  67.     *cp++ = pkth->nodes;    /* The number of nodes */
  68.     (void) put16 (cp, pkth->envid);    /* The envelope-ID */
  69.     return bp;
  70. }
  71.  
  72.  
  73.  
  74. /* Convert RSPF header in mbuf to internal structure */
  75. int
  76. ntohrspf (union rspf *rspf, struct mbuf **bpp)
  77. {
  78.     if (len_p (*bpp) < RSPFPKTLEN)    /* Packet too short */
  79.         return -1;
  80.     if ((rspf->hdr.version = (char) pullchar (bpp)) != RSPF_VERSION) {
  81.         ++Rspf_stat.badvers;
  82.         return -1;    /* Wrong version */
  83.     }
  84.     switch (rspf->hdr.type = (char) pullchar (bpp)) {
  85.         case RSPF_RRH:
  86.             if (len_p (*bpp) < RRHLEN - 2)    /* Packet too small */
  87.                 return -1;
  88.             rspf->rrh.csum = (int16) pull16 (bpp);
  89.             rspf->rrh.addr = pull32 (bpp);
  90.             rspf->rrh.seq = (int16) pull16 (bpp);
  91.             rspf->rrh.flags = (char) pullchar (bpp);
  92.             break;
  93.         case RSPF_FULLPKT:
  94.             rspf->pkthdr.fragn = uchar (pullchar (bpp));
  95.             rspf->pkthdr.fragtot = uchar (pullchar (bpp));
  96.             rspf->pkthdr.csum = (int16) pull16 (bpp);
  97.             rspf->pkthdr.sync = uchar (pullchar (bpp));
  98.             rspf->pkthdr.nodes = uchar (pullchar (bpp));
  99.             rspf->pkthdr.envid = (int16) pull16 (bpp);
  100.             break;
  101.         default:
  102.             return -1;
  103.     }
  104.     return 0;
  105. }
  106.  
  107.  
  108.  
  109. /* Convert RSPF node header in internal format to an mbuf in external format */
  110. struct mbuf *
  111. htonrspfnode (struct rspfnodeh *nodeh, struct mbuf *data)
  112. {
  113. struct mbuf *bp;
  114. register unsigned char *cp;
  115.  
  116.     /* Allocate node header and fill it in */
  117.     bp = pushdown (data, RSPFNODELEN);    /* pushdown never fails */
  118.  
  119.     cp = bp->data;
  120.     cp = put32 (cp, nodeh->addr);    /* Reporting router address */
  121.     cp = put16 (cp, (int16) nodeh->seq);    /* Sequence number */
  122.     *cp++ = nodeh->subseq;    /* Sub-sequence number */
  123.     *cp++ = nodeh->links;    /* Number of links */
  124.     return bp;
  125. }
  126.  
  127.  
  128.  
  129. /* Convert RSPF node header in mbuf to internal structure */
  130. int
  131. ntohrspfnode (struct rspfnodeh *nodeh, struct mbuf **bpp)
  132. {
  133.     if (len_p (*bpp) < RSPFNODELEN)    /* Packet too short */
  134.         return -1;
  135.     nodeh->addr = pull32 (bpp);
  136.     nodeh->seq = (short) pull16 (bpp);
  137.     nodeh->subseq = (unsigned char) pullchar (bpp);
  138.     nodeh->links = (unsigned char) pullchar (bpp);
  139.     return 0;
  140. }
  141.  
  142.  
  143.  
  144. /* Convert RSPF link header in internal format to an mbuf in external format */
  145. struct mbuf *
  146. htonrspflink (struct rspflinkh *linkh, struct mbuf *data)
  147. {
  148. struct mbuf *bp;
  149. register unsigned char *cp;
  150.  
  151.     /* Allocate link header and fill it in */
  152.     bp = pushdown (data, RSPFLINKLEN);    /* pushdown never fails */
  153.  
  154.     cp = bp->data;
  155.     *cp++ = linkh->horizon;    /* Horizon */
  156.     *cp++ = linkh->erp;    /* ERP factor */
  157.     *cp++ = linkh->cost;    /* Link cost */
  158.     *cp++ = linkh->adjn;    /* Number of adjacencies */
  159.     return bp;
  160. }
  161.  
  162.  
  163.  
  164. /* Convert RSPF link header in mbuf to internal structure */
  165. int
  166. ntohrspflink (struct rspflinkh *linkh, struct mbuf **bpp)
  167. {
  168.     if (len_p (*bpp) < RSPFLINKLEN)    /* Packet too short */
  169.         return -1;
  170.     linkh->horizon = (unsigned char) pullchar (bpp);
  171.     linkh->erp = (unsigned char) pullchar (bpp);
  172.     linkh->cost = (unsigned char) pullchar (bpp);
  173.     linkh->adjn = (unsigned char) pullchar (bpp);
  174.     return 0;
  175. }
  176.  
  177. #endif /* RSPF */
  178.